﻿using System;
using System.Text;
using System.ComponentModel;
using System.Collections.Generic;
using Sinacor.Infra.UI.Common;
using System.Runtime.Serialization;
using System.Collections.ObjectModel;

namespace Sinacor.UI.Bovespa.Corretagem.Presenter
{
    public class CadastroTaxa : BasePresenter<ICadastroTaxa>
    { 
        #region Campos

        private Communication.Taxa _taxasCommunication;
        private Communication.Mercado _mercadoCommunication;

        private Communication.Negocio _negocioCommunication;
                
        private ModelCollection<Model.Taxa> _taxas;
        private ModelCollection<Model.Bolsa> _bolsa;
        private ModelCollection<Model.Bolsa> _bolsatpt;

        private ObservableCollection<EnumWrapper<Model.Enum.TipoCliente>> _listaCliente;
        private ObservableCollection<EnumWrapper<Model.Enum.TipoLiquidacao>> _listaLiquidacao;
        private ObservableCollection<EnumWrapper<Model.Enum.TipoPapel>> _listaAtivo;
        private ObservableCollection<EnumWrapper<Model.Enum.TipoOperacao>> _listaOperacao;

        private ModelCollection<Model.Mercado> _mercado;
        private ModelCollection<Model.Mercado> _mercadoOrigem;

        private ModelCollection<Model.Mercado> _mercadotpt;
        private ModelCollection<Model.Mercado> _mercadoOrigemtpt;
        
        private Model.Parameter.FiltroTaxa _filtrotaxa;
        private Model.Taxa _taxa;
        
        #endregion

        #region Construtor

        public CadastroTaxa(ICadastroTaxa cadastrotaxaview)
            : base(cadastrotaxaview)
        {
            _taxasCommunication = new Communication.Taxa(this.Session);
            _negocioCommunication = new Communication.Negocio(this.Session);
            _mercadoCommunication = new Communication.Mercado(this.Session); 

            _filtrotaxa = new Model.Parameter.FiltroTaxa();
            _taxa = new Model.Taxa();
            _taxas = new ModelCollection<Model.Taxa>(); 
        }

        #endregion

        #region Propriedades

        public ModelCollection<Model.Taxa> Taxas
        {
            get { return _taxas; }
            set {
                _taxas = value;
                if (_taxas != null)
                {
                    this.Taxas.EnableStateControl = true;
                }
            }
        }

        public ModelCollection<Model.Bolsa> Bolsa
        {
            get { return _bolsa; }
            set { _bolsa = value; }
        }

        public ModelCollection<Model.Bolsa> BolsaTPT
        {
            get { return _bolsatpt; }
            set { _bolsatpt = value; }
        }
        
        public ObservableCollection<EnumWrapper<Model.Enum.TipoCliente>> ListaCliente
        {
            get { return _listaCliente; }
            set { _listaCliente = value; }
        }

        public ObservableCollection<EnumWrapper<Model.Enum.TipoLiquidacao>> ListaLiquidacao
        {
            get { return _listaLiquidacao; }
            set { _listaLiquidacao = value; }
        }

        public ObservableCollection<EnumWrapper<Model.Enum.TipoPapel>> ListaAtivo
        {
            get { return _listaAtivo; }
            set { _listaAtivo = value; }
        }

        public ObservableCollection<EnumWrapper<Model.Enum.TipoOperacao>> ListaOperacao
        {
            get { return _listaOperacao; }
            set { _listaOperacao = value; }
        }

        public ModelCollection<Model.Mercado> Mercado
        {
            get { return _mercado; }
            set { _mercado = value; }
        }

        public ModelCollection<Model.Mercado> MercadoOrigem
        {
            get { return _mercadoOrigem; }
            set { _mercadoOrigem = value; }
        }

        public ModelCollection<Model.Mercado> MercadoTPT
        {
            get { return _mercadotpt; }
            set { _mercadotpt = value; }
        }

        public ModelCollection<Model.Mercado> MercadoOrigemTPT
        {
            get { return _mercadoOrigemtpt; }
            set { _mercadoOrigemtpt = value; }
        }

        public Model.Parameter.FiltroTaxa FiltroTaxa
        {
            get { return _filtrotaxa; }
            set { _filtrotaxa = value; }
        }

        public Model.Taxa Taxa
        {
            get { return _taxa; }
            set { _taxa = value; }
        }

        #endregion


        #region Métodos

        public void ExcluirTaxa(Model.ChaveTaxa request)
        {
            try
            {
                _taxasCommunication.ExcluirTaxa(request);
                
                View.AtualizarTaxas();
                View.InformarTaxaExcluidaSucesso();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void IncluirTaxa(Model.Taxa request)
        {
            try
            {
                _taxasCommunication.IncluirTaxa(request);

                View.AtualizarTaxas();
                View.InformarTaxaIncluidaSucesso();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void AlterarTaxa(Model.Taxa request)
        {
            try
            {
                _taxasCommunication.AlterarTaxa(request);

                View.AtualizarTaxas();
                View.InformarTaxaAlteradaSucesso();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }


        public void ConsultarTaxas(Model.Parameter.FiltroTaxa request)
        {
            try
            {
                _taxas = _taxasCommunication.ConsultarTaxas(request);

                if (_taxas.Count == 0)
                    View.InformarNenhumaTaxaEncontrada(); 

                View.AtualizarTaxas();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void ConsultarMercados()
        {
            try
            {
                Model.Parameter.FiltroMercado filtromercado = new Model.Parameter.FiltroMercado();

                _mercado = _mercadoCommunication.ConsultarMercados(filtromercado);
                
                _mercadoOrigem = new ModelCollection<Model.Mercado>();              
                foreach (var item in _mercado)
                {
                    _mercadoOrigem.Add(new Model.Mercado { 
                                                Codigo = item.Codigo,
                                                CodigoAlfa = item.CodigoAlfa,
                                                Descricao = item.Descricao  
                                                }); 
                }
                
                View.AtualizarMercado();
                View.AtualizarMercadoOrigem();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarMercadoEdit()
        {
            try
            {
                _mercadotpt = new ModelCollection<Model.Mercado>();

                foreach (var item in _mercado)
                {
                    _mercadotpt.Add(new Model.Mercado
                    {
                        Codigo = item.Codigo,
                        CodigoAlfa = item.CodigoAlfa,
                        Descricao = item.Descricao
                    });
                }
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarMercadoOrigemEdit()
        {
            try
            {
                _mercadoOrigemtpt = new ModelCollection<Model.Mercado>();

                foreach (var item in _mercado)
                {
                    _mercadoOrigemtpt.Add(new Model.Mercado
                    {
                        Codigo = item.Codigo,
                        CodigoAlfa = item.CodigoAlfa,
                        Descricao = item.Descricao
                    });
                }

            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void ConsultarBolsas()
        {
            try
            {
                _bolsa = _negocioCommunication.ConsultarBolsas();

                View.AtualizarBolsa();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarBolsa()
        {
            try
            {
                _bolsatpt = new ModelCollection<Model.Bolsa>();

                foreach (var item in _bolsa)
                {
                    _bolsatpt.Add(new Model.Bolsa
                    {
                        Codigo = item.Codigo,
                        Descricao = item.Descricao
                    });
                }    

            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }


        public void CarregarMercados()
        {
            try
            {
                View.AtualizarMercado();
                View.AtualizarMercadoOrigem(); 
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarOperacao()
        {
            try
            {
                _listaOperacao = CriarOperacao();

            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarClientes()
        {
            try
            {
                _listaCliente = CriarClientes();
                
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarLiquidacao()
        {
            try
            {
                _listaLiquidacao = CriarLiquidacao();

            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        public void CarregarAtivo()
        {
            try
            {
                _listaAtivo = CriarAtivo();

            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }

        private ObservableCollection<EnumWrapper<Model.Enum.TipoOperacao>> CriarOperacao()
        {
            return EnumWrapper<Model.Enum.TipoOperacao>.GetEnums(
                                              Model.Enum.TipoOperacao.DayTrade ,
                                              Model.Enum.TipoOperacao.OperacoesCobertas ,
                                              Model.Enum.TipoOperacao.OperacoesFinais ,
                                              Model.Enum.TipoOperacao.Precatorios 
                                         );
        }

        private ObservableCollection<EnumWrapper<Model.Enum.TipoCliente>> CriarClientes()
        {
            return EnumWrapper<Model.Enum.TipoCliente>.GetEnums(
                                              Model.Enum.TipoCliente.CarteiraPropria,
                                              Model.Enum.TipoCliente.FundosClubeInvestimento,
                                              Model.Enum.TipoCliente.Normal
                                         );
        }

        private ObservableCollection<EnumWrapper<Model.Enum.TipoLiquidacao>> CriarLiquidacao()
        {
            return EnumWrapper<Model.Enum.TipoLiquidacao>.GetEnums(
                                              Model.Enum.TipoLiquidacao.Balcao,
                                              Model.Enum.TipoLiquidacao.DesmancheBox,
                                              Model.Enum.TipoLiquidacao.Direto,
                                              Model.Enum.TipoLiquidacao.Lancador,
                                              Model.Enum.TipoLiquidacao.LiquidacaoBruta,
                                              Model.Enum.TipoLiquidacao.Normal,
                                              Model.Enum.TipoLiquidacao.OperacaoBox,
                                              Model.Enum.TipoLiquidacao.Tomador,
                                              Model.Enum.TipoLiquidacao.POP,
                                              Model.Enum.TipoLiquidacao.TVR,
                                              Model.Enum.TipoLiquidacao.BTF
                                         );
        }


        private ObservableCollection<EnumWrapper<Model.Enum.TipoPapel>> CriarAtivo()
        {
            return EnumWrapper<Model.Enum.TipoPapel>.GetEnums(
                                              Model.Enum.TipoPapel.Debentures ,
                                              Model.Enum.TipoPapel.Especialista ,
                                              Model.Enum.TipoPapel.Indice ,
                                              Model.Enum.TipoPapel.Normal ,
                                              Model.Enum.TipoPapel.Recibos ,
                                              Model.Enum.TipoPapel.POP,
                                              Model.Enum.TipoPapel.CRI
                                         );
        }

        private ObservableCollection<EnumWrapper<Model.Enum.TipoMercado>> CriarMercado()
        {
            return EnumWrapper<Model.Enum.TipoMercado>.GetEnums(
                                              Model.Enum.TipoMercado.BOX,
                                              Model.Enum.TipoMercado.Estruturado,
                                              Model.Enum.TipoMercado.ExercicioOpcaoCompra,

                                              Model.Enum.TipoMercado.Fracionario,
                                              Model.Enum.TipoMercado.Futuro,
                                              Model.Enum.TipoMercado.Leilao,

                                              Model.Enum.TipoMercado.LeilaoNaoCotados,
                                              Model.Enum.TipoMercado.OpcaoCompra,
                                              Model.Enum.TipoMercado.OpcaoVenda,

                                              Model.Enum.TipoMercado.Termo,
                                              Model.Enum.TipoMercado.VencimentoFuturo,
                                              Model.Enum.TipoMercado.Vista
                                         );
        }

        public void LimparPesquisa()
        {
            try
            {                
                View.AtualizarNovaPesquisa();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
        }


        #endregion
    }
}
